package com.yt.product.api.client;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.yt.common.constant.Result;
import com.yt.common.enums.CodeEnum;
import com.yt.product.models.bo.SupplierInfoBO;
import com.yt.product.models.dto.SupplierInfoDTO;
import com.yt.product.models.service.ISupplierInfoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.Map;

/**
 * 供应商信息控制器
 *
 * @author lianyadong
 * @Date 2025-09-03 14:16:03
 */
@RestController
@RequestMapping("/api/supplierInfo")
@Slf4j
@Api(value = "SupplierInfoApiController", tags = "供应商信息Api接口")
public class SupplierInfoApiController {

    @DubboReference
    private ISupplierInfoService supplierInfoService;

    // 原有接口：根据ID查询供应商
    @PostMapping("/get")
    @ApiOperation(value = "根据id查找", notes = "根据供应商ID查询详情")
    @ApiImplicitParam(name = "id", value = "供应商ID", required = true, paramType = "query", dataType = "Long")
    public Result<SupplierInfoDTO> get(@RequestParam("id") Long id) {
        if (id == null) {
            log.warn("查询供应商失败：ID为空");
            return new Result<>(CodeEnum.FAIL_100002); // 参数不能为空
        }
        SupplierInfoDTO dto = supplierInfoService.selectById(id);
        log.info("根据ID:{}查询供应商，结果：{}", id, dto != null ? "存在" : "不存在");
        return new Result<>(dto);
    }

    // 原有接口：分页查询供应商列表
    @PostMapping("/queryPageList")
    @ApiOperation(value = "供应商信息列表", notes = "分页查询供应商列表，支持状态、时间范围筛选")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNo", value = "当前页码", defaultValue = "1", paramType = "query", dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页条数", defaultValue = "10", paramType = "query", dataType = "Integer"),
            @ApiImplicitParam(name = "status", value = "供应商状态（0=禁用，1=启用，2=已删除）", required = false, paramType = "query", dataType = "Integer"),
            @ApiImplicitParam(name = "startDate", value = "创建时间起始（格式：yyyy-MM-dd HH:mm:ss）", required = false, paramType = "query", dataType = "String"),
            @ApiImplicitParam(name = "endDate", value = "创建时间结束（格式：yyyy-MM-dd HH:mm:ss）", required = false, paramType = "query", dataType = "String")
    })
    public Result<Page<SupplierInfoDTO>> queryPageList(
            @RequestParam(defaultValue = "1") Integer pageNo,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestBody(required = false) SupplierInfoBO bo) { // BO参数使用@RequestBody接收
        // 1. 构建查询条件
        EntityWrapper<SupplierInfoDTO> wrapper = new EntityWrapper<>();
        if (bo != null) {
            if (bo.getStatus() != null) {
                wrapper.eq("status", bo.getStatus());
                log.info("筛选条件：状态={}", bo.getStatus());
            }
            if (bo.getStartDate() != null) {
                wrapper.ge("create_time", bo.getStartDate());
                log.info("筛选条件：创建时间≥{}", bo.getStartDate());
            }
            if (bo.getEndDate() != null) {
                wrapper.le("create_time", bo.getEndDate());
                log.info("筛选条件：创建时间≤{}", bo.getEndDate());
            }
        }
        // 默认不查询已删除的供应商（状态≠2），避免前端列表显示已删除数据
        wrapper.ne("status", 2);
        // 2. 分页查询
        Page<SupplierInfoDTO> page = new Page<>(pageNo, pageSize);
        page = supplierInfoService.selectPage(page, wrapper);
        log.info("分页查询供应商列表：页码={}，条数={}，总记录数={}", pageNo, pageSize, page.getTotal());
        return new Result<>(page);
    }

    // 新增接口：更新供应商状态（启用/禁用）
    @PostMapping("/updateStatus")
    @ApiOperation(value = "更新供应商状态", notes = "启用/禁用供应商，status=1启用，status=0禁用；不允许设置为2（已删除）")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "供应商ID", required = true, paramType = "body", dataType = "Long"),
            @ApiImplicitParam(name = "status", value = "目标状态（0=禁用，1=启用）", required = true, paramType = "body", dataType = "Integer")
    })
    public Result updateStatus(@RequestBody Map<String, Object> params) {
        // 1. 解析并校验参数（匹配前端JSON请求格式）
        Long id = parseLongParam(params.get("id"), "供应商ID");
        Integer status = parseIntegerParam(params.get("status"), "供应商状态");

        if (id == null) {
            return new Result<>(CodeEnum.FAIL_100002); // ID不能为空
        }
        if (status == null || (status != 0 && status != 1)) {
            log.warn("更新供应商状态失败：无效状态（status={}，仅支持0/1）", status);
            return new Result<>(CodeEnum.FAIL_100003); // 状态参数错误
        }

        // 2. 校验供应商是否存在且未删除
        SupplierInfoDTO existDto = supplierInfoService.selectById(id);
        if (existDto == null) {
            log.warn("更新供应商状态失败：ID={}的供应商不存在", id);
            return new Result<>(CodeEnum.FAIL_100004); // 记录不存在
        }
        if (existDto.getStatus() == 2) {
            log.warn("更新供应商状态失败：ID={}的供应商已删除，无法操作", id);
            return new Result<>(CodeEnum.FAIL_100005); // 已删除记录不允许操作
        }
        if (existDto.getStatus().equals(status)) {
            log.info("更新供应商状态：ID={}，当前状态已为{}，无需操作", id, status);
            return new Result<>(); // 状态无变化，视为成功
        }

        // 3. 调用Service更新状态（同步修改时间）
        SupplierInfoDTO updateDto = new SupplierInfoDTO();
        updateDto.setId(id);
        updateDto.setStatus(status);
        updateDto.setUpdateTime(new Date()); // 记录修改时间
        boolean success = supplierInfoService.updateById(updateDto);

        // 4. 日志与返回结果
        if (success) {
            log.info("更新供应商状态成功：ID={}，旧状态={}，新状态={}", id, existDto.getStatus(), status);
            return new Result<>(); // 成功响应
        } else {
            log.error("更新供应商状态失败：ID={}（数据库操作失败）", id);
            return new Result<>(CodeEnum.FAIL_100006); // 操作失败
        }
    }

    // 新增参数解析工具方法（与产品接口保持一致）
    private Long parseLongParam(Object param, String paramName) {
        if (param == null) {
            log.warn("{}为空", paramName);
            return null;
        }
        try {
            if (param instanceof Number) {
                return ((Number) param).longValue();
            } else {
                return Long.parseLong(param.toString());
            }
        } catch (NumberFormatException e) {
            log.warn("{}格式错误：{}", paramName, param);
            return null;
        }
    }

    private Integer parseIntegerParam(Object param, String paramName) {
        if (param == null) {
            log.warn("{}为空", paramName);
            return null;
        }
        try {
            if (param instanceof Number) {
                return ((Number) param).intValue();
            } else {
                return Integer.parseInt(param.toString());
            }
        } catch (NumberFormatException e) {
            log.warn("{}格式错误：{}", paramName, param);
            return null;
        }
    }

    // 新增接口：更新供应商完整信息
    @PostMapping("/update")
    @ApiOperation(value = "更新供应商完整信息", notes = "修改供应商的名称、电话、地址和状态等信息")
    public Result<Boolean> update(@RequestBody SupplierInfoBO bo) {
        // 1. 参数校验
        if (bo.getId() == null) {
            log.warn("更新供应商信息失败：ID为空");
            return new Result<>(CodeEnum.FAIL_100002); // 参数不能为空
        }

        // 2. 校验供应商是否存在且未删除
        SupplierInfoDTO existDto = supplierInfoService.selectById(bo.getId());
        if (existDto == null) {
            log.warn("更新供应商信息失败：ID={}的供应商不存在", bo.getId());
            return new Result<>(CodeEnum.FAIL_100004); // 记录不存在
        }
        if (existDto.getStatus() == 2) {
            log.warn("更新供应商信息失败：ID={}的供应商已删除，无法修改", bo.getId());
            return new Result<>(CodeEnum.FAIL_100005); // 已删除记录不允许操作
        }

        // 3. 转换BO到DTO并设置更新时间
        SupplierInfoDTO updateDto = new SupplierInfoDTO();
        BeanUtils.copyProperties(bo, updateDto);
        updateDto.setUpdateTime(new Date()); // 更新时间为当前时间

        // 4. 调用服务层执行更新
        boolean success = supplierInfoService.updateById(updateDto);

        // 5. 日志记录与结果返回
        log.info("更新供应商信息：ID={}，结果：{}", bo.getId(), success ? "成功" : "失败");
        return success ? new Result<>(true) : new Result<>(CodeEnum.FAIL_100006); // 操作失败
    }
    // 新增接口：删除供应商（逻辑删除，设置状态为2）
    @PostMapping("/delete")
    @ApiOperation(value = "删除供应商", notes = "逻辑删除供应商，将状态设置为2（已删除）")
    @ApiImplicitParam(name = "id", value = "供应商ID", required = true, paramType = "body", dataType = "Long")
    public Result<Boolean> delete(@RequestBody Map<String, Object> params) {
        // 1. 获取并校验ID
        Long id = (Long) params.get("id");
        if (id == null) {
            log.warn("删除供应商失败：ID为空");
            return new Result<>(CodeEnum.FAIL_100002); // 参数不能为空
        }

        // 2. 校验供应商是否存在
        SupplierInfoDTO existDto = supplierInfoService.selectById(id);
        if (existDto == null) {
            log.warn("删除供应商失败：ID={}不存在", id);
            return new Result<>(CodeEnum.FAIL_100004); // 记录不存在
        }

        // 3. 校验是否已删除
        if (existDto.getStatus() == 2) {
            log.warn("删除供应商失败：ID={}已删除", id);
            return new Result<>(CodeEnum.FAIL_100005); // 已删除不允许操作
        }

        // 4. 执行逻辑删除（更新状态为2）
        SupplierInfoDTO updateDto = new SupplierInfoDTO();
        updateDto.setId(id);
        updateDto.setStatus(2); // 标记为已删除
        updateDto.setUpdateTime(new Date());

        boolean success = supplierInfoService.updateById(updateDto);
        log.info("删除供应商ID={}，结果：{}", id, success ? "成功" : "失败");

        return success ? new Result<>(true) : new Result<>(CodeEnum.FAIL_100006); // 操作失败
    }
}